/**
 * Copyright (c) 2005-2011 springside.org.cn
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * 
 * $Id: HibernateDao.java 1547 2011-05-05 14:43:07Z calvinxiu $
 */
package com.se7en.core.orm.hibernate;

import java.io.Serializable;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

import org.apache.commons.lang.StringUtils;
import org.hibernate.Criteria;
import org.hibernate.Query;
import org.hibernate.SQLQuery;
import org.hibernate.criterion.CriteriaSpecification;
import org.hibernate.criterion.Criterion;
import org.hibernate.criterion.Disjunction;
import org.hibernate.criterion.MatchMode;
import org.hibernate.criterion.Projection;
import org.hibernate.criterion.Projections;
import org.hibernate.criterion.Restrictions;
import org.hibernate.impl.CriteriaImpl;
import org.hibernate.transform.AliasToBeanResultTransformer;
import org.hibernate.transform.ResultTransformer;

import com.se7en.core.orm.Page;
import com.se7en.core.orm.PageRequest;
import com.se7en.core.orm.PropertyFilter;
import com.se7en.core.orm.PropertyFilter.MatchType;
import com.se7en.core.utils.AssertUtils;
import com.se7en.core.utils.ReflectionUtils;

/**
 * 封装SpringSide扩展功能的Hibernate DAO泛型基类.
 * 
 * 扩展功能包括分页查询,按属性过滤条件列表查询.
 * 
 * @param <T>
 *            DAO操作的对象类型
 * @param <ID>
 *            主键类型
 * 
 */
@SuppressWarnings("unchecked")
public class HibernateDao<T, ID extends Serializable> extends SimpleHibernateDao<T, ID> {

    public static final String DEFAULT_ALIAS = "x";

    /**
     * 通过子类的泛型定义取得对象类型Class. eg. public class UserDao extends HibernateDao<User,
     * Long>{ }
     */
    public HibernateDao() {
        super();
    }

    public HibernateDao(Class<T> entityClass) {
        super(entityClass);
    }

    // -- 分页查询函数 --//

    /**
     * 分页获取全部对象.
     */
    public Page<T> getAll(final PageRequest pageRequest) {
        return findPage(pageRequest);
    }

    /**
     * 按HQL分页查询.
     * 
     * @param pageRequest
     *            分页参数.
     * @param hql
     *            hql语句.
     * @param values
     *            数量可变的查询参数,按顺序绑定.
     * 
     * @return 分页查询结果, 附带结果列表及所有查询输入参数.
     */
    public Page<T> findPage(final PageRequest pageRequest, String hql, final Object... values) {
        AssertUtils.notNull(pageRequest, "pageRequest不能为空");

        Page<T> page = new Page<T>(pageRequest);

        if (pageRequest.isCountTotal()) {
            long totalCount = countHqlResult(hql, values);
            page.setTotalItems(totalCount);
        }

        Query q = createQuery(hql, values);

        setPageParameterToQuery(q, pageRequest);

        List result = q.list();
        page.setResult(result);
        return page;
    }

    /**
     * 按HQL分页查询.
     * 
     * @param page
     *            分页参数.
     * @param hql
     *            hql语句.
     * @param values
     *            命名参数,按名称绑定.
     * 
     * @return 分页查询结果, 附带结果列表及所有查询输入参数.
     */
    public Page<T> findPage(final PageRequest pageRequest, String hql, final Map<String, ?> values) {
        AssertUtils.notNull(pageRequest, "page不能为空");

        Page<T> page = new Page<T>(pageRequest);

        if (pageRequest.isCountTotal()) {
            long totalCount = countHqlResult(hql, values);
            page.setTotalItems(totalCount);
        }

        Query q = createQuery(hql, values);
        setPageParameterToQuery(q, pageRequest);

        List result = q.list();
        page.setResult(result);
        return page;
    }

    public <X> Page<X> findPage(final PageRequest pageRequest, String hql, final Map<String, ?> values, Class<X> clasz) {
        AssertUtils.notNull(pageRequest, "pageRequest不能为空");

        Page<X> page = new Page<X>(pageRequest);

        if (pageRequest.isCountTotal()) {
            long totalCount = countHqlResult(hql, values);
            page.setTotalItems(totalCount);
        }

        Query q = createQuery(hql, values);
        q.setResultTransformer(new AliasToBeanResultTransformer(clasz));
        setPageParameterToQuery(q, pageRequest);

        List result = q.list();
        page.setResult(result);
        return page;
    }

    /**
     * 按HQL分页查询.
     * 
     * @param page
     *            分页参数.
     * @param hql
     *            hql语句.
     * @param values
     *            命名参数,按名称绑定.
     * 
     * @return 分页查询结果, 附带结果列表及所有查询输入参数.
     */
    public <X> Page<X> findPageSQL(final PageRequest pageRequest, String sql, final Map<String, ?> values,
            Class<X> clasz) {
        AssertUtils.notNull(pageRequest, "page不能为空");

        Page<X> page = new Page<X>(pageRequest);

        if (pageRequest.isCountTotal()) {
            long totalCount = countSqlResult(sql, values);
            page.setTotalItems(totalCount);
        }

        Query q = createSQLQuery(sql, values);
        q.setResultTransformer(new AliasToBeanResultTransformer(clasz));
        setPageParameterToQuery(q, pageRequest);

        List result = q.list();
        page.setResult(result);
        return page;
    }

    /**
     * 按SQL分页查询.
     * 
     * @param page
     *            分页参数.
     * @param hql
     *            hql语句.
     * @param values
     *            命名参数,按名称绑定.
     * @param scalars
     *            列绑定
     * @return 分页查询结果, 附带结果列表及所有查询输入参数.
     */
    public <X> Page<X> findPageSQL(final PageRequest pageRequest, String sql, final Map<String, ?> values,
            List<String> scalars, Class<X> clasz) {
        AssertUtils.notNull(pageRequest, "page不能为空");

        Page<X> page = new Page<X>(pageRequest);

        if (pageRequest.isCountTotal()) {
            long totalCount = countSqlResult(sql, values);
            page.setTotalItems(totalCount);
        }

        SQLQuery q = (SQLQuery) createSQLQuery(sql, values);
        if (scalars != null && scalars.size() > 0) {
            for (String scalar : scalars) {
                q.addScalar(scalar);
            }
        }
        q.setResultTransformer(new AliasToBeanResultTransformer(clasz));
        setPageParameterToQuery(q, pageRequest);

        List result = q.list();
        page.setResult(result);
        return page;
    }

    /**
     * 按SQL分页查询.
     * 
     * @param sql语句
     *            .
     * @param values
     *            命名参数,按名称绑定.
     * @param scalars
     *            列绑定
     * @return 分页查询结果, 附带结果列表及所有查询输入参数.
     */
    public List<T> findSQL(String sql, final Map<String, ?> values, List<String> scalars, Class clasz) {
        SQLQuery q = (SQLQuery) createSQLQuery(sql, values);
        if (scalars != null && scalars.size() > 0) {
            for (String scalar : scalars) {
                q.addScalar(scalar);
            }
        }
        q.setResultTransformer(new AliasToBeanResultTransformer(clasz));
        List<T> result = q.list();
        return result;
    }

    /**
     * 郑永标
     * 
     * @param sql语句
     *            .
     * @param values
     *            命名参数,按名称绑定.
     * @param scalars
     *            列绑定
     * @return 返回唯一实体类
     */
    public T findUniqueResultBySql(String sql, final Map<String, ?> values, List<String> scalars, Class clasz) {
        SQLQuery q = (SQLQuery) createSQLQuery(sql, values);
        if (scalars != null && scalars.size() > 0) {
            for (String scalar : scalars) {
                q.addScalar(scalar);
            }
        }
        q.setResultTransformer(new AliasToBeanResultTransformer(clasz));
        return (T) q.uniqueResult();
    }

    /**
     * 按Criteria分页查询.
     * 
     * @param page
     *            分页参数.
     * @param criterions
     *            数量可变的Criterion.
     * 
     * @return 分页查询结果.附带结果列表及所有查询输入参数.
     */
    public Page<T> findPage(final PageRequest pageRequest, final Criterion... criterions) {
        AssertUtils.notNull(pageRequest, "page不能为空");

        Page<T> page = new Page<T>(pageRequest);

        Criteria c = createCriteria(criterions);

        if (pageRequest.isCountTotal()) {
            long totalCount = countCriteriaResult(c);
            page.setTotalItems(totalCount);
        }

        setPageRequestToCriteria(c, pageRequest);

        List result = c.list();
        page.setResult(result);
        return page;
    }

    public Page<T> findPage(final PageRequest pageRequest, final Criteria criteria) {
        AssertUtils.notNull(pageRequest, "page不能为空");

        Page<T> page = new Page<T>(pageRequest);

        if (pageRequest.isCountTotal()) {
            long totalCount = countCriteriaResult(criteria);
            page.setTotalItems(totalCount);
        }

        setPageRequestToCriteria(criteria, pageRequest);

        List result = criteria.list();
        page.setResult(result);
        return page;
    }

    /**
     * 设置分页参数到Query对象,辅助函数.
     */
    protected Query setPageParameterToQuery(final Query q, final PageRequest pageRequest) {
        q.setFirstResult(pageRequest.getOffset());
        q.setMaxResults(pageRequest.getPageSize());
        return q;
    }

    /**
     * 设置分页参数到Criteria对象,辅助函数.
     */
    protected Criteria setPageRequestToCriteria(final Criteria c, final PageRequest pageRequest) {
        AssertUtils.isTrue(pageRequest.getPageSize() > 0, "Page Size must larger than zero");

        c.setFirstResult(pageRequest.getOffset());
        c.setMaxResults(pageRequest.getPageSize());
        return c;
    }

    /**
     * 执行count查询获得本次Hql查询所能获得的对象总数.
     * 
     * 本函数只能自动处理简单的hql语句,复杂的hql查询请另行编写count语句查询.
     */
    protected long countHqlResult(final String hql, final Object... values) {
        String countHql = prepareCountHql(hql);

        try {
            Long count = findUnique(countHql, values);
            return count;
        } catch (Exception e) {
            throw new RuntimeException("hql can't be auto count, hql is:" + countHql, e);
        }
    }

    /**
     * 执行count查询获得本次Hql查询所能获得的对象总数.
     * 
     * 本函数只能自动处理简单的hql语句,复杂的hql查询请另行编写count语句查询.
     */
    protected long countHqlResult(final String hql, final Map<String, ?> values) {
        String countHql = prepareCountHql(hql);
        countHql = StringUtils.replace(countHql, " fetch ", " ");
        try {
            Long count = findUnique(countHql, values);
            return count;
        } catch (Exception e) {
            throw new RuntimeException("hql can't be auto count, hql is:" + countHql, e);
        }
    }

    protected long countSqlResult(final String sql, final Map<String, ?> values) {
        String countHql = prepareCountHql(sql);
        countHql = StringUtils.replace(countHql, " fetch ", " ");
        try {
            Object count = findUniqueSQL(countHql, values);
            return Long.parseLong(count + "");
        } catch (Exception e) {
            throw new RuntimeException("hql can't be auto count, hql is:" + countHql, e);
        }
    }

    private String prepareCountHql(String orgHql) {
        String countHql = "select count(*) " + removeSelect(removeOrders(orgHql));
        return countHql;
    }

    private static String removeSelect(String hql) {
        int beginPos = hql.toLowerCase().indexOf("from");
        return hql.substring(beginPos);
    }

    private static String removeOrders(String hql) {
        Pattern p = Pattern.compile("order\\s*by[\\w|\\W|\\s|\\S]*", Pattern.CASE_INSENSITIVE);
        Matcher m = p.matcher(hql);
        StringBuffer sb = new StringBuffer();
        while (m.find()) {
            m.appendReplacement(sb, "");
        }
        m.appendTail(sb);
        return sb.toString();
    }

    /**
     * 执行count查询获得本次Criteria查询所能获得的对象总数.
     */
    protected long countCriteriaResult(final Criteria c) {
        CriteriaImpl impl = (CriteriaImpl) c;

        // 先把Projection、ResultTransformer、OrderBy取出来,清空三者后再执行Count操作
        Projection projection = impl.getProjection();
        ResultTransformer transformer = impl.getResultTransformer();

        List<CriteriaImpl.OrderEntry> orderEntries = null;
        try {
            orderEntries = (List) ReflectionUtils.getFieldValue(impl, "orderEntries");
            ReflectionUtils.setFieldValue(impl, "orderEntries", new ArrayList());
        } catch (Exception e) {
            logger.error("不可能抛出的异常:{}", e.getMessage());
        }

        // 执行Count查询
        Long totalCountObject = (Long) c.setProjection(Projections.rowCount()).uniqueResult();
        long totalCount = (totalCountObject != null) ? totalCountObject : 0;

        // 将之前的Projection,ResultTransformer和OrderBy条件重新设回去
        c.setProjection(projection);

        if (projection == null) {
            c.setResultTransformer(CriteriaSpecification.ROOT_ENTITY);
        }
        if (transformer != null) {
            c.setResultTransformer(transformer);
        }
        try {
            ReflectionUtils.setFieldValue(impl, "orderEntries", orderEntries);
        } catch (Exception e) {
            logger.error("不可能抛出的异常:{}", e.getMessage());
        }

        return totalCount;
    }

    // -- 属性过滤条件(PropertyFilter)查询函数 --//

    /**
     * 按属性查找对象列表,支持多种匹配方式.
     * 
     * @param matchType
     *            匹配方式,目前支持的取值见PropertyFilter的MatcheType enum.
     */
    public List<T> findBy(final String propertyName, final Object value, final MatchType matchType) {
        Criterion criterion = buildCriterion(propertyName, value, matchType);
        return find(criterion);
    }

    /**
     * 按属性过滤条件列表查找对象列表.
     */
    public List<T> find(List<PropertyFilter> filters) {
        Criterion[] criterions = buildCriterionByPropertyFilter(filters);
        return find(criterions);
    }

    /**
     * 按属性过滤条件列表分页查找对象.
     */
    public Page<T> findPage(final PageRequest pageRequest, final List<PropertyFilter> filters) {
        Criterion[] criterions = buildCriterionByPropertyFilter(filters);
        return findPage(pageRequest, criterions);
    }

    /**
     * 按属性条件参数创建Criterion,辅助函数.
     */
    protected Criterion buildCriterion(final String propertyName, final Object propertyValue, final MatchType matchType) {
        AssertUtils.hasText(propertyName, "propertyName不能为空");
        Criterion criterion = null;
        // 根据MatchType构造criterion
        switch (matchType) {
        case EQ:
            criterion = Restrictions.eq(propertyName, propertyValue);
            break;
        case LIKE:
            criterion = Restrictions.like(propertyName, (String) propertyValue, MatchMode.ANYWHERE);
            break;

        case LE:
            criterion = Restrictions.le(propertyName, propertyValue);
            break;
        case LT:
            criterion = Restrictions.lt(propertyName, propertyValue);
            break;
        case GE:
            criterion = Restrictions.ge(propertyName, propertyValue);
            break;
        case GT:
            criterion = Restrictions.gt(propertyName, propertyValue);
        }
        return criterion;
    }

    /**
     * 按属性条件列表创建Criterion数组,辅助函数.
     */
    protected Criterion[] buildCriterionByPropertyFilter(final List<PropertyFilter> filters) {
        List<Criterion> criterionList = new ArrayList<Criterion>();
        for (PropertyFilter filter : filters) {
            if (!filter.hasMultiProperties()) { // 只有一个属性需要比较的情况.
                Criterion criterion = buildCriterion(filter.getPropertyName(), filter.getMatchValue(), filter
                        .getMatchType());
                criterionList.add(criterion);
            } else {// 包含多个属性需要比较的情况,进行or处理.
                Disjunction disjunction = Restrictions.disjunction();
                for (String param : filter.getPropertyNames()) {
                    Criterion criterion = buildCriterion(param, filter.getMatchValue(), filter.getMatchType());
                    disjunction.add(criterion);
                }
                criterionList.add(disjunction);
            }
        }
        return criterionList.toArray(new Criterion[criterionList.size()]);
    }

    /*
     * public Page<T> findPage(final PageRequest pageRequest, final
     * DetachedCriteria detachedCriteria) { AssertUtils.notNull(pageRequest,
     * "pageRequest不能为空");
     * 
     * Criteria c = detachedCriteria.getExecutableCriteria(this.getSession());
     * Page<T> page = new Page<T>(pageRequest);
     * 
     * if (pageRequest.isCountTotal()) { long totalCount =
     * countCriteriaResult(c); page.setTotalItems(totalCount); }
     * 
     * setPageRequestToCriteria(c, pageRequest); List result = c.list();
     * page.setResult(result); return page; }
     */
}
